home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / video / fly8111-.000 / fly8111- / fly8 / stroke.c < prev    next >
C/C++ Source or Header  |  1979-12-31  |  8KB  |  367 lines
  1. /* --------------------------------- stroke.c ------------------------------- */
  2.  
  3. /* This is part of the flight simulator 'fly8'.
  4.  * Author: Eyal Lebedinsky (eyal@ise.canberra.edu.au).
  5. */
  6.  
  7. /* text in graphics window - stroke painting.
  8. */
  9.  
  10. #include "fly.h"
  11.  
  12.  
  13. static Uchar NEAR* NEAR* FAR StFonts[] = {
  14.     (Uchar NEAR* NEAR*)StFont1,    /*  0 */
  15.     (Uchar NEAR* NEAR*)StFont2,    /*  1 */
  16.     (Uchar NEAR* NEAR*)StFont1,    /*  2 */
  17.     (Uchar NEAR* NEAR*)StFont1,    /*  3 */
  18.     (Uchar NEAR* NEAR*)StFont1,    /*  4 */
  19.     (Uchar NEAR* NEAR*)StFont1,    /*  5 */
  20.     (Uchar NEAR* NEAR*)StFont1,    /*  6 */
  21.     (Uchar NEAR* NEAR*)StFont1,    /*  7 */
  22.     (Uchar NEAR* NEAR*)StFont1,    /*  8 */
  23.     (Uchar NEAR* NEAR*)StFont1    /*  9 */
  24. };
  25.  
  26. #define    Font    st.StFontPtr
  27.  
  28. #define Sc(s)    {s*0/8, s*1/8, s*2/8, s*3/8, s*4/8, s*5/8, s*6/8, s*7/8}
  29.  
  30. static int NEAR Scales[][8] = {
  31. Sc(0),  Sc(1),  Sc(2),  Sc(3),  Sc(4),  Sc(5),  Sc(6),  Sc(7),  Sc(8),  Sc(9),
  32. Sc(10), Sc(11), Sc(12), Sc(13), Sc(14), Sc(15), Sc(16), Sc(17), Sc(18), Sc(19),
  33. Sc(20), Sc(21), Sc(22), Sc(23), Sc(24), Sc(25), Sc(26), Sc(27), Sc(28), Sc(29),
  34. Sc(30), Sc(31), Sc(32), Sc(33), Sc(34), Sc(35), Sc(36), Sc(37), Sc(38), Sc(39),
  35. Sc(40), Sc(41), Sc(42), Sc(43), Sc(44), Sc(45), Sc(46), Sc(47), Sc(48), Sc(49),
  36. Sc(50), Sc(51), Sc(52), Sc(53), Sc(54), Sc(55), Sc(56), Sc(57), Sc(58), Sc(59),
  37. Sc(60), Sc(61), Sc(62), Sc(63), Sc(64), Sc(65), Sc(66), Sc(67), Sc(68), Sc(69),
  38. Sc(70), Sc(71), Sc(72), Sc(73), Sc(74), Sc(75), Sc(76), Sc(77), Sc(78), Sc(79),
  39. Sc(80), Sc(81), Sc(82), Sc(83), Sc(84), Sc(85), Sc(86), Sc(87), Sc(88), Sc(89),
  40. Sc(90), Sc(91), Sc(92), Sc(93), Sc(94), Sc(95), Sc(96), Sc(97), Sc(98), Sc(99),
  41. Sc(100), Sc(101), Sc(102), Sc(103), Sc(104), 
  42. Sc(105), Sc(106), Sc(107), Sc(108), Sc(109),
  43. Sc(110), Sc(111), Sc(112), Sc(113), Sc(114), 
  44. Sc(115), Sc(116), Sc(117), Sc(118), Sc(119),
  45. Sc(120), Sc(121), Sc(122), Sc(123), Sc(124),
  46. Sc(125), Sc(126), Sc(127), Sc(128),
  47. {0}};
  48.  
  49. #undef Sc
  50.  
  51. static ANGLE    StrokeAngle = 0;
  52. static int    CosAngle = FONE, SinAngle = 0;
  53. static int    StrokeX = 0, StrokeY = 0;
  54. static int    StrokeDecChar = '.';
  55.  
  56. extern int FAR
  57. font_set (int font)
  58. {
  59.     int    i;
  60.  
  61.     i = st.StFont;
  62.     if (font >= 0) {
  63.         st.StFont = font;
  64.         st.StFontPtr = StFonts[st.StFont];
  65.     }
  66.     return (i);
  67. }
  68.  
  69. extern void FAR
  70. stroke_angle (ANGLE angle)
  71. {
  72.     StrokeAngle = angle;
  73.     SinAngle = SIN (angle);
  74.     CosAngle = COS (angle);
  75. }
  76.  
  77. extern int FAR
  78. stroke_decimal (int c)
  79. {
  80.     int    s;
  81.  
  82.     s = StrokeDecChar;
  83.     StrokeDecChar = c;
  84.     return (s);
  85. }
  86.  
  87. extern int FAR
  88. num_size (long num, int ss)
  89. {
  90.     int    size, dss, n;
  91.  
  92.     if (ss <= 0 || ss > rangeof (Scales))
  93.         return (0);
  94.  
  95.     if (num < 0L) {
  96.         num = -num;
  97.         size = Scales[ss][0x0f&(Font['-'][0]>>4)];
  98.     } else
  99.         size = 0;
  100.     dss = Scales[ss][0x0f&(Font['0'][0]>>4)];
  101.  
  102.     if (num < 10000L)
  103.         if (num < 100L)
  104.             if (num < 10L)
  105.                 n = 1;
  106.             else
  107.                 n = 2;
  108.         else
  109.             if (num < 1000L)
  110.                 n = 3;
  111.             else
  112.                 n = 4;
  113.     else
  114.         if (num < 1000000L)
  115.             if (num < 100000L)
  116.                 n = 5;
  117.             else
  118.                 n = 6;
  119.         else
  120.             if (num < 10000000L)
  121.                 n = 7;
  122.             else if (num < 100000000L)
  123.                 n = 8;
  124.             else
  125.                 n = 9;
  126.  
  127.     return (size+dss*n);
  128. }
  129.  
  130. extern void FAR
  131. num_extent (long num, int ss, int *exs, int *exc, int *eys, int *eyc)
  132. {
  133.     int    dx;
  134.  
  135.     dx = num_size (num, ss);
  136.     *exs = fmul (dx, SinAngle);
  137.     *exc = fmul (dx, CosAngle);
  138.     *eys = fmul (ss, SinAngle);
  139.     *eyc = fmul (ss, CosAngle);
  140. }
  141.  
  142. extern int FAR
  143. char_size (int Char, int size)
  144. {
  145.     register int    NEAR* scale;
  146.  
  147.     if (size <= 0 || size > rangeof (Scales))
  148.         return (0);
  149.  
  150.     scale = Scales[size];
  151.     return (Font[Char]
  152.         ? scale[0x0f&(Font[Char][0]>>4)]
  153.         : scale[0x0f&(Font[0x100][0]>>4)]);
  154. }
  155.  
  156. extern int FAR
  157. stroke_size (char *s, int size)
  158. {
  159.     register int    NEAR* scale;
  160.     register int    tsize, Char;
  161.  
  162.     if (!s || size <= 0 || size > rangeof (Scales))
  163.         return (0);
  164.  
  165.     scale = Scales[size];
  166.     for (tsize = 0; T(Char = *s++);) {
  167.         if (Font[Char])
  168.             tsize += scale[0x0f&(Font[Char][0]>>4)];
  169.         else
  170.             tsize += scale[0x0f&(Font[0x100][0]>>4)];
  171.     }
  172.  
  173.     return (tsize);
  174. }
  175.  
  176. #define stroke_line(scale,x,dx,y,dy,t) \
  177.     if ('\x00' == (t)) \
  178.         gr_draw ((x)+scale[dx], (y)-scale[dy]); \
  179.     else \
  180.         gr_move ((x)+scale[dx], (y)-scale[dy])
  181.  
  182. #define my_sign(x)    ((x) < 0 ? -1 : 1)
  183. #define my_round(x)    (((x) + my_sign (x)) >> 1)
  184.     
  185. LOCAL_FUNC void NEAR
  186. stroke_rot (int    NEAR* scale, int x, int dx, int y, int dy, int t)
  187. {
  188.     int    xx, yy;
  189.  
  190.     dx = scale[dx] << 1;
  191.     dy = scale[dy] << 1;
  192.     xx = fmul (dx, CosAngle) - fmul (dy, SinAngle);
  193.     yy = fmul (dx, SinAngle) + fmul (dy, CosAngle);
  194.  
  195.     x += my_round (xx);
  196.     y -= my_round (yy);
  197.     if ('\x00' == t)
  198.         gr_draw (x, y);
  199.     else
  200.         gr_move (x, y);
  201. }
  202.  
  203. LOCAL_FUNC int NEAR
  204. stroke_c (int Char, int size)
  205. {
  206.     register int    NEAR* scale;
  207.     register Uchar    NEAR* p;
  208.     register int    t, xy;
  209.     int        move;
  210.  
  211.     if (!(p = Font[Char]))
  212.         p = Font[0x100];
  213.  
  214.     scale = Scales[size];
  215.     if (StrokeAngle) {
  216.         for (move = *p++; (t = *p++) < '\x02';) {
  217.             xy = *p++;
  218.             stroke_rot (scale, StrokeX, 0x0f&(xy>>4),
  219.                             StrokeY, 0x0f&xy, t);
  220.         }
  221.         move = scale[0x0f&(move>>4)];
  222.         xy = fmul (move<<1, CosAngle);
  223.         StrokeX += my_round (xy);
  224.         xy = fmul (move<<1, SinAngle);
  225.         StrokeY -= my_round (xy);
  226.     } else {
  227.         for (move = *p++; (t = *p++) < '\x02';) {
  228.             xy = *p++;
  229.             stroke_line (scale, StrokeX, 0x0f&(xy>>4),
  230.                             StrokeY, 0x0f&xy, t);
  231.         }
  232.         move = scale[0x0f&(move>>4)];
  233.         StrokeX += move;
  234.     }
  235.     return (move);
  236. }
  237.  
  238. extern int FAR
  239. stroke_char (int x, int y, int Char, int size, int color)
  240. {
  241.     StrokeX = x;
  242.     StrokeY = y;
  243.     gr_color (color);
  244.  
  245.     if (size <= 0 || size > rangeof (Scales))
  246.         return (0);
  247.  
  248.     return (stroke_c (Char, size));
  249. }
  250.  
  251. extern int FAR
  252. stroke_str (int x, int y, char *p, int size, int color)
  253. {
  254.     int    ch, numsize;
  255.  
  256.     StrokeX = x;
  257.     StrokeY = y;
  258.     gr_color (color);
  259.  
  260.     if (!p || !*p)
  261.         return (0);
  262.  
  263.     if (size <= 0 || size > rangeof (Scales))
  264.         return (0);
  265.  
  266.     for (numsize = 0; T(ch = *p); ++p)
  267.         numsize += stroke_c (ch, size);
  268.     return (numsize);
  269. }
  270.  
  271. extern int FAR
  272. stroke_num (int x, int y, long num, int size, int color)
  273. {
  274.     char    buf[15];
  275.  
  276.     sprintf (buf, "%ld", num);
  277.     return (stroke_str (x, y, buf, size, color));
  278. }
  279.  
  280. static Ulong magsize[] = {
  281.     1UL, 10UL, 100UL, 1000UL, 10000UL, 100000UL,
  282.     1000000UL, 10000000UL, 100000000UL, 1000000000UL,
  283. };
  284.  
  285. extern int FAR
  286. frac_size (long num, int digits, int frac, int ss)
  287. {
  288.     int    n, ndigits;
  289.  
  290.     if (ss <= 0 || ss > rangeof (Scales))
  291.         return (0);
  292.  
  293.     n = Scales[ss][0x0f&(Font[StrokeDecChar][0]>>4)];
  294.     if (num < 0) {
  295.         n += Scales[ss][0x0f&(Font['-'][0]>>4)];
  296.         num = -num;
  297.     }
  298.     if (digits > 0)
  299.         ndigits = digits;
  300.     else {
  301.         if (frac >= rangeof(magsize))
  302.             frac = rangeof(magsize) - 1;
  303.         if ((Ulong)num >= magsize[frac]) {
  304.             for (ndigits = frac; (Ulong)num >= magsize[++ndigits];)
  305.                 if (ndigits >= rangeof(magsize))
  306.                     break;
  307.         } else {
  308.             if (0 == digits)
  309.                 ndigits = frac + 1;
  310.             else
  311.                 ndigits = frac;
  312.         }
  313.     }
  314.  
  315.     n += Scales[ss][0x0f&(Font['0'][0]>>4)] * ndigits;
  316.     return (n);
  317.  
  318. }
  319.  
  320. extern int FAR
  321. stroke_frac (int x, int y, long num, int digits, int frac, int size, int color)
  322. /*
  323.  * Show 't' in 'digits' positions and a decimal point 'frac' positions from
  324.  * the right. If 'digits' is zero then the number of positions will be just as
  325.  * many as will be needed with at least one integer digit. If 'digits' is -1
  326.  * then fractions can start with the decimal point.
  327.  * If 'digits' is less than 'frac' then the number will be truncated!
  328. */
  329. {
  330.     char    buf[15], *p;
  331.     int    len, numsize;
  332.  
  333.     StrokeX = x;
  334.     StrokeY = y;
  335.     gr_color (color);
  336.  
  337.     if (size <= 0 || size > rangeof (Scales))
  338.         return (0);
  339.  
  340.     if (num < 0) {
  341.         numsize = stroke_c ('-', size);
  342.         num = -num;
  343.     } else
  344.         numsize = 0;
  345.     sprintf (buf, "%ld", num);
  346.     len = strlen (p = buf);
  347.  
  348.     if (-1 == digits)
  349.         digits = (len > frac) ? len : frac;
  350.     else if (0 == digits)
  351.         digits = (len > frac) ? len : frac+1;
  352.  
  353.     gr_color (color);
  354.     for (; digits > 0; --digits) {
  355.         if (digits == frac)
  356.             numsize += stroke_c (StrokeDecChar, size);
  357.         numsize += stroke_c ((digits > len) ? '0' : *p++, size);
  358.     }
  359.     return (numsize);
  360. }
  361.  
  362. #undef Font
  363. #undef stroke_line
  364. #undef my_sign
  365. #undef my_round
  366.  
  367.